import dayjs from 'dayjs'
import relativeTime from 'dayjs/plugin/relativeTime'
import 'dayjs/locale/zh-cn'

// 配置dayjs
dayjs.extend(relativeTime)
dayjs.locale('zh-cn')

/**
 * 格式化数字
 * @param {number} num 数字
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的数字字符串
 */
export function formatNumber(num, decimals = 2) {
  if (num === null || num === undefined || isNaN(num)) {
    return '0'
  }
  
  const absNum = Math.abs(num)
  
  if (absNum >= 1e9) {
    return (num / 1e9).toFixed(decimals) + 'B'
  } else if (absNum >= 1e6) {
    return (num / 1e6).toFixed(decimals) + 'M'
  } else if (absNum >= 1e3) {
    return (num / 1e3).toFixed(decimals) + 'K'
  } else {
    return num.toFixed(decimals)
  }
}

/**
 * 格式化金额
 * @param {number} amount 金额
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的金额字符串
 */
export function formatAmount(amount, decimals = 2) {
  if (amount === null || amount === undefined || isNaN(amount)) {
    return '0.00$'
  }
  
  // 直接显示完整数值，保留两位小数
  return `${amount.toFixed(decimals)}$`
}

/**
 * 格式化净爆仓金额（万元单位）
 * @param {number} amount 金额
 * @returns {string} 格式化后的金额字符串
 */
export function formatNetAmount(amount) {
  if (amount === null || amount === undefined || isNaN(amount)) {
    return '0万$'
  }
  
  const absAmount = Math.abs(amount)
  
  if (absAmount >= 1e8) {
    return `${(amount / 1e8).toFixed(2)}亿$`
  } else if (absAmount >= 1e4) {
    return `${(amount / 1e4).toFixed(2)}万$`
  } else {
    return `${amount.toFixed(2)}$`
  }
}

/**
 * 计算净爆仓量
 * @param {number} longAmount 多头爆仓金额
 * @param {number} shortAmount 空头爆仓金额
 * @returns {object} 包含净爆仓量和类型的对象
 */
export function calculateNetLiquidation(longAmount, shortAmount) {
  const netAmount = longAmount - shortAmount
  return {
    amount: netAmount,
    type: netAmount > 0 ? 'long' : netAmount < 0 ? 'short' : 'neutral',
    isLong: netAmount > 0,
    isShort: netAmount < 0
  }
}

/**
 * 格式化体积（使用中文单位：万、亿）
 * @param {number} volume 体积
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的体积字符串
 */
export function formatVolume(volume, decimals = 4) {
  if (volume === null || volume === undefined || isNaN(volume)) {
    return '0'
  }

  const abs = Math.abs(volume)
  if (abs >= 1e8) {
    return (volume / 1e8).toFixed(decimals) + '亿'
  } else if (abs >= 1e4) {
    return (volume / 1e4).toFixed(decimals) + '万'
  } else {
    return volume.toFixed(decimals)
  }
}

/**
 * 格式化百分比
 * @param {number} value 数值
 * @param {number} total 总数
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的百分比字符串
 */
export function formatPercentage(value, total, decimals = 2) {
  if (!total || total === 0) {
    return '0%'
  }
  
  return ((value / total) * 100).toFixed(decimals) + '%'
}

/**
 * 格式化百分比（直接传入百分比值）
 * @param {number} percent 百分比值
 * @param {number} decimals 小数位数
 * @returns {string} 格式化后的百分比字符串
 */
export function formatPercent(percent, decimals = 2) {
  if (percent === null || percent === undefined || isNaN(percent)) {
    return '0%'
  }
  
  return percent.toFixed(decimals) + '%'
}

/**
 * 格式化时间
 * @param {number|string|Date} time 时间戳或时间字符串
 * @param {string} format 格式化模板
 * @returns {string} 格式化后的时间字符串
 */
export function formatTime(time, format = 'YYYY-MM-DD HH:mm:ss') {
  if (!time) {
    return '-'
  }
  
  return dayjs(time).format(format)
}

/**
 * 格式化相对时间（精确显示，如 5秒前、3分钟前、2小时前）
 * @param {number|string|Date} time 时间戳或时间字符串
 * @returns {string} 相对时间字符串
 */
export function formatRelativeTime(time) {
  if (!time) return '-'

  const ts = typeof time === 'number' ? time : dayjs(time).valueOf()
  if (!ts) return '-'

  const now = Date.now()
  let diffSec = Math.floor((now - ts) / 1000)
  if (diffSec < 0) diffSec = 0

  if (diffSec < 60) {
    return `${diffSec}秒前`
  }
  const minutes = Math.floor(diffSec / 60)
  if (minutes < 60) {
    return `${minutes}分钟前`
  }
  const hours = Math.floor(minutes / 60)
  if (hours < 24) {
    return `${hours}小时前`
  }
  const days = Math.floor(hours / 24)
  if (days < 30) {
    return `${days}天前`
  }
  const months = Math.floor(days / 30)
  if (months < 12) {
    return `${months}个月前`
  }
  const years = Math.floor(months / 12)
  return `${years}年前`
}

/**
 * 格式化币种名称
 * @param {string} coin 币种名称
 * @returns {string} 格式化后的币种名称
 */
export function formatCoinName(coin) {
  if (!coin) {
    return '-'
  }
  
  return coin.toUpperCase()
}

/**
 * 获取多空方向的颜色
 * @param {string} side 方向 (long/short)
 * @returns {string} 颜色类名
 */
export function getSideColor(side) {
  switch (side?.toLowerCase()) {
    case 'long':
      return 'success'
    case 'short':
      return 'danger'
    default:
      return 'info'
  }
}

/**
 * 获取多空方向的文本
 * @param {string} side 方向 (long/short)
 * @returns {string} 中文文本
 */
export function getSideText(side) {
  switch (side?.toLowerCase()) {
    case 'long':
      return '多头'
    case 'short':
      return '空头'
    default:
      return '未知'
  }
}

/**
 * 格式化时间窗口标签
 * @param {string} window 时间窗口键
 * @returns {string} 时间窗口标签
 */
export function formatTimeWindowLabel(window) {
  const labels = {
    '1m': '1分钟',
    '3m': '3分钟',
    '5m': '5分钟',
    '10m': '10分钟',
    '15m': '15分钟'
  }
  
  return labels[window] || window
}

/**
 * 计算涨跌幅颜色
 * @param {number} value 数值
 * @returns {string} 颜色类名
 */
export function getChangeColor(value) {
  if (value > 0) {
    return 'success'
  } else if (value < 0) {
    return 'danger'
  } else {
    return 'info'
  }
}

/**
 * 格式化文件大小
 * @param {number} bytes 字节数
 * @returns {string} 格式化后的文件大小
 */
export function formatFileSize(bytes) {
  if (bytes === 0) return '0 B'
  
  const k = 1024
  const sizes = ['B', 'KB', 'MB', 'GB', 'TB']
  const i = Math.floor(Math.log(bytes) / Math.log(k))
  
  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i]
}

/**
 * 防抖函数
 * @param {Function} func 要防抖的函数
 * @param {number} wait 等待时间
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, wait) {
  let timeout
  return function executedFunction(...args) {
    const later = () => {
      clearTimeout(timeout)
      func(...args)
    }
    clearTimeout(timeout)
    timeout = setTimeout(later, wait)
  }
}

/**
 * 节流函数
 * @param {Function} func 要节流的函数
 * @param {number} limit 时间限制
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle
  return function executedFunction(...args) {
    if (!inThrottle) {
      func.apply(this, args)
      inThrottle = true
      setTimeout(() => inThrottle = false, limit)
    }
  }
}